wiki/User-Guide.md:1313

• This newly-unignored Rust snippet defines the Config trait but references Serialize, DeserializeOwned, Hash, and Debug without importing or qualifying them. If someone runs scripts/verify-markdown-code.sh across the repo, this block will fail to compile; please make it self-contained by adding the needed use statements (or fully-qualifying the paths).
  wiki/Determinism-Model.md:394
• This code example uses panic!() for desync handling. The project’s documentation guidelines call for zero-panic patterns in examples (prefer returning Result / propagating errors or logging + clean shutdown). Please update this snippet to demonstrate non-panicking desync handling so users don’t copy/paste a panic-based pattern.

wiki/User-Guide.md:1314

• This block is now tagged as rust but it’s not a self-contained Rust snippet (e.g., `Serialize`, `DeserializeOwned`, `Hash`, `Debug` aren’t in scope here). If this is meant as illustrative API shape rather than copy/pasteable code, consider switching the fence to text, or add the minimal use imports so the example compiles as shown.
  wiki/User-Guide.md:1345
• This code block is now labeled as rust, but it uses placeholders (`MyConfig`, `remote_addr`) and depends on the `tokio` feature (`#[tokio::main]`, `TokioUdpSocket`). If the intent is a copy/pasteable example, add the missing placeholder definitions and wrap tokio-specific parts in `#[cfg(feature = "tokio")]` (or use a text fence if it’s illustrative only).
  wiki/User-Guide.md:1385
• This example calls SpecViolation::to_json(), which is only available with the json feature, but the snippet itself doesn’t show how to guard feature-gated code (and it’s now tagged as rust). Consider either adding a `#[cfg(feature = "json")]` wrapper around the `to_json()` usage (with a brief fallback example), or switching this block to text if it’s not meant to compile as-is.
  wiki/User-Guide.md:505
• This block is tagged as rust but references `game_state` without defining it in the snippet. If the goal is a copy/pasteable example, include a minimal `GameState` value in this same block (or switch to a text fence for illustrative fragments).
  wiki/User-Guide.md:517
• This example is now labeled as rust, but it depends on `game_state` being defined elsewhere (and uses `?`). For better copy/paste ergonomics, make the snippet self-contained (define `game_state` and any needed imports/types in this block) or change the fence to text if it’s intentionally partial.
  src/lib.rs:1115
• The docs for impl From<usize> for Frame say it “silently truncates values larger than i32::MAX”. The value as i32 cast can also wrap into negative values (e.g. i32::MAX as usize + 1 becomes i32::MIN), not just “truncate above max”. Please update the wording to reflect the actual wrap/truncation behavior (and that it may yield negative/invalid frames).

wiki/Determinism-Model.md:394

• This documentation example uses panic! for desync handling. Since the project’s guidance emphasizes panic-free examples, it would be better to show a non-panicking pattern (e.g., logging + early return / signaling via an application error) so readers don’t copy a crash-on-desync approach.
  examples/configuration.rs:108
• The comment says this is equivalent to .with_lan_defaults(), but this builder uses TimeSyncConfig::responsive() whereas with_lan_defaults() applies TimeSyncConfig::lan(). Either switch to TimeSyncConfig::lan() or adjust the comment so it doesn’t imply exact equivalence.

    // LAN/Local play - fast connections, minimal latency
    // Equivalent to: .with_lan_defaults()
    let lan_builder = SessionBuilder::<GameConfig>::new()
        .with_num_players(2)
        .unwrap()
        .with_sync_config(SyncConfig::lan())
        .with_protocol_config(ProtocolConfig::competitive())
        .with_time_sync_config(TimeSyncConfig::responsive())
        .with_input_delay(0)

examples/configuration.rs:146

• The comment says this is similar to .with_high_latency_defaults(), but with_high_latency_defaults() applies the mobile() presets (and also adjusts the input queue), while this example uses the high_latency()/smooth() presets and doesn’t set InputQueueConfig::high_latency(). Consider either using the preset method directly in the example or adjusting the comment to avoid implying similarity to that preset.

    // High-latency networks (80-200ms RTT)
    // Similar to: .with_high_latency_defaults().with_max_prediction_window(12)
    let high_latency_builder = SessionBuilder::<GameConfig>::new()
        .with_num_players(2)
        .unwrap()
        .with_sync_config(SyncConfig::high_latency())
        .with_protocol_config(ProtocolConfig::high_latency())
        .with_time_sync_config(TimeSyncConfig::smooth())
        .with_input_delay(4)
        .unwrap()